home *** CD-ROM | disk | FTP | other *** search
/ Revista do CD-ROM 124 / cd-rom 124.iso / edu / tuxmath / tuxmathscrabble / tuxmathscrabble.exe / sre_compile.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2003-11-16  |  10.8 KB  |  459 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.2)
  3.  
  4. import _sre
  5. import sys
  6. from sre_constants import *
  7. MAXCODE = 65535
  8.  
  9. def _compile(code, pattern, flags):
  10.     emit = code.append
  11.     for op, av in pattern:
  12.         if op in (LITERAL, NOT_LITERAL):
  13.             if flags & SRE_FLAG_IGNORECASE:
  14.                 emit(OPCODES[OP_IGNORE[op]])
  15.                 emit(_sre.getlower(av, flags))
  16.             else:
  17.                 emit(OPCODES[op])
  18.                 emit(av)
  19.         elif op is IN:
  20.             if flags & SRE_FLAG_IGNORECASE:
  21.                 emit(OPCODES[OP_IGNORE[op]])
  22.                 
  23.                 def fixup(literal, flags = flags):
  24.                     return _sre.getlower(literal, flags)
  25.  
  26.             else:
  27.                 emit(OPCODES[op])
  28.                 
  29.                 fixup = lambda x: x
  30.             skip = len(code)
  31.             emit(0)
  32.             _compile_charset(av, flags, code, fixup)
  33.             code[skip] = len(code) - skip
  34.         elif op is ANY:
  35.             if flags & SRE_FLAG_DOTALL:
  36.                 emit(OPCODES[ANY_ALL])
  37.             else:
  38.                 emit(OPCODES[ANY])
  39.         elif op in (REPEAT, MIN_REPEAT, MAX_REPEAT):
  40.             if flags & SRE_FLAG_TEMPLATE:
  41.                 raise error, 'internal: unsupported template operator'
  42.                 emit(OPCODES[REPEAT])
  43.                 skip = len(code)
  44.                 emit(0)
  45.                 emit(av[0])
  46.                 emit(av[1])
  47.                 _compile(code, av[2], flags)
  48.                 emit(OPCODES[SUCCESS])
  49.                 code[skip] = len(code) - skip
  50.             elif _simple(av) and op == MAX_REPEAT:
  51.                 emit(OPCODES[REPEAT_ONE])
  52.                 skip = len(code)
  53.                 emit(0)
  54.                 emit(av[0])
  55.                 emit(av[1])
  56.                 _compile(code, av[2], flags)
  57.                 emit(OPCODES[SUCCESS])
  58.                 code[skip] = len(code) - skip
  59.             else:
  60.                 emit(OPCODES[REPEAT])
  61.                 skip = len(code)
  62.                 emit(0)
  63.                 emit(av[0])
  64.                 emit(av[1])
  65.                 _compile(code, av[2], flags)
  66.                 code[skip] = len(code) - skip
  67.                 if op == MAX_REPEAT:
  68.                     emit(OPCODES[MAX_UNTIL])
  69.                 else:
  70.                     emit(OPCODES[MIN_UNTIL])
  71.         elif op is SUBPATTERN:
  72.             if av[0]:
  73.                 emit(OPCODES[MARK])
  74.                 emit((av[0] - 1) * 2)
  75.             
  76.             _compile(code, av[1], flags)
  77.             if av[0]:
  78.                 emit(OPCODES[MARK])
  79.                 emit((av[0] - 1) * 2 + 1)
  80.             
  81.         elif op in (SUCCESS, FAILURE):
  82.             emit(OPCODES[op])
  83.         elif op in (ASSERT, ASSERT_NOT):
  84.             emit(OPCODES[op])
  85.             skip = len(code)
  86.             emit(0)
  87.             if av[0] >= 0:
  88.                 emit(0)
  89.             else:
  90.                 (lo, hi) = av[1].getwidth()
  91.                 if lo != hi:
  92.                     raise error, 'look-behind requires fixed-width pattern'
  93.                 
  94.                 emit(lo)
  95.             _compile(code, av[1], flags)
  96.             emit(OPCODES[SUCCESS])
  97.             code[skip] = len(code) - skip
  98.         elif op is CALL:
  99.             emit(OPCODES[op])
  100.             skip = len(code)
  101.             emit(0)
  102.             _compile(code, av, flags)
  103.             emit(OPCODES[SUCCESS])
  104.             code[skip] = len(code) - skip
  105.         elif op is AT:
  106.             emit(OPCODES[op])
  107.             if flags & SRE_FLAG_MULTILINE:
  108.                 av = AT_MULTILINE.get(av, av)
  109.             
  110.             if flags & SRE_FLAG_LOCALE:
  111.                 av = AT_LOCALE.get(av, av)
  112.             elif flags & SRE_FLAG_UNICODE:
  113.                 av = AT_UNICODE.get(av, av)
  114.             
  115.             emit(ATCODES[av])
  116.         elif op is BRANCH:
  117.             emit(OPCODES[op])
  118.             tail = []
  119.             for av in av[1]:
  120.                 skip = len(code)
  121.                 emit(0)
  122.                 _compile(code, av, flags)
  123.                 emit(OPCODES[JUMP])
  124.                 tail.append(len(code))
  125.                 emit(0)
  126.                 code[skip] = len(code) - skip
  127.             
  128.             emit(0)
  129.             for tail in tail:
  130.                 code[tail] = len(code) - tail
  131.             
  132.         elif op is CATEGORY:
  133.             emit(OPCODES[op])
  134.             if flags & SRE_FLAG_LOCALE:
  135.                 av = CH_LOCALE[av]
  136.             elif flags & SRE_FLAG_UNICODE:
  137.                 av = CH_UNICODE[av]
  138.             
  139.             emit(CHCODES[av])
  140.         elif op is GROUPREF:
  141.             if flags & SRE_FLAG_IGNORECASE:
  142.                 emit(OPCODES[OP_IGNORE[op]])
  143.             else:
  144.                 emit(OPCODES[op])
  145.             emit(av - 1)
  146.         else:
  147.             raise ValueError, ('unsupported operand type', op)
  148.     
  149.  
  150.  
  151. def _compile_charset(charset, flags, code, fixup = None):
  152.     emit = code.append
  153.     if not fixup:
  154.         
  155.         fixup = lambda x: x
  156.     
  157.     for op, av in _optimize_charset(charset, fixup):
  158.         emit(OPCODES[op])
  159.         if op is NEGATE:
  160.             pass
  161.         elif op is LITERAL:
  162.             emit(fixup(av))
  163.         elif op is RANGE:
  164.             emit(fixup(av[0]))
  165.             emit(fixup(av[1]))
  166.         elif op is CHARSET:
  167.             code.extend(av)
  168.         elif op is BIGCHARSET:
  169.             code.extend(av)
  170.         elif op is CATEGORY:
  171.             if flags & SRE_FLAG_LOCALE:
  172.                 emit(CHCODES[CH_LOCALE[av]])
  173.             elif flags & SRE_FLAG_UNICODE:
  174.                 emit(CHCODES[CH_UNICODE[av]])
  175.             else:
  176.                 emit(CHCODES[av])
  177.         else:
  178.             raise error, 'internal: unsupported set operator'
  179.     
  180.     emit(OPCODES[FAILURE])
  181.  
  182.  
  183. def _optimize_charset(charset, fixup):
  184.     out = []
  185.     charmap = [
  186.         0] * 256
  187.     
  188.     try:
  189.         for op, av in charset:
  190.             if op is NEGATE:
  191.                 out.append((op, av))
  192.             elif op is LITERAL:
  193.                 charmap[fixup(av)] = 1
  194.             elif op is RANGE:
  195.                 for i in range(fixup(av[0]), fixup(av[1]) + 1):
  196.                     charmap[i] = 1
  197.                 
  198.             elif op is CATEGORY:
  199.                 return charset
  200.             
  201.     except IndexError:
  202.         if sys.maxunicode != 65535:
  203.             return charset
  204.         
  205.         return _optimize_unicode(charset, fixup)
  206.  
  207.     i = p = n = 0
  208.     runs = []
  209.     for c in charmap:
  210.         if c:
  211.             if n == 0:
  212.                 p = i
  213.             
  214.             n = n + 1
  215.         elif n:
  216.             runs.append((p, n))
  217.             n = 0
  218.         
  219.         i = i + 1
  220.     
  221.     if n:
  222.         runs.append((p, n))
  223.     
  224.     if len(runs) <= 2:
  225.         for p, n in runs:
  226.             if n == 1:
  227.                 out.append((LITERAL, p))
  228.             else:
  229.                 out.append((RANGE, (p, p + n - 1)))
  230.         
  231.         if len(out) < len(charset):
  232.             return out
  233.         
  234.     else:
  235.         data = _mk_bitmap(charmap)
  236.         out.append((CHARSET, data))
  237.         return out
  238.     return charset
  239.  
  240.  
  241. def _mk_bitmap(bits):
  242.     data = []
  243.     m = 1
  244.     v = 0
  245.     for c in bits:
  246.         if c:
  247.             v = v + m
  248.         
  249.         m = m << 1
  250.         if m > MAXCODE:
  251.             data.append(v)
  252.             m = 1
  253.             v = 0
  254.         
  255.     
  256.     return data
  257.  
  258.  
  259. def _optimize_unicode(charset, fixup):
  260.     charmap = [
  261.         0] * 65536
  262.     negate = 0
  263.     for op, av in charset:
  264.         if op is NEGATE:
  265.             negate = 1
  266.         elif op is LITERAL:
  267.             charmap[fixup(av)] = 1
  268.         elif op is RANGE:
  269.             for i in range(fixup(av[0]), fixup(av[1]) + 1):
  270.                 charmap[i] = 1
  271.             
  272.         elif op is CATEGORY:
  273.             return charset
  274.         
  275.     
  276.     if negate:
  277.         for i in range(65536):
  278.             charmap[i] = not charmap[i]
  279.         
  280.     
  281.     comps = { }
  282.     mapping = [
  283.         0] * 256
  284.     block = 0
  285.     data = []
  286.     for i in range(256):
  287.         chunk = tuple(charmap[i * 256:(i + 1) * 256])
  288.         new = comps.setdefault(chunk, block)
  289.         mapping[i] = new
  290.         if new == block:
  291.             block = block + 1
  292.             data = data + _mk_bitmap(chunk)
  293.         
  294.     
  295.     header = [
  296.         block]
  297.     for i in range(128):
  298.         if sys.byteorder == 'big':
  299.             header.append(256 * mapping[2 * i] + mapping[2 * i + 1])
  300.         else:
  301.             header.append(mapping[2 * i] + 256 * mapping[2 * i + 1])
  302.     
  303.     data[0:0] = header
  304.     return [
  305.         (BIGCHARSET, data)]
  306.  
  307.  
  308. def _simple(av):
  309.     (lo, hi) = av[2].getwidth()
  310.     if lo == 0 and hi == MAXREPEAT:
  311.         raise error, 'nothing to repeat'
  312.     
  313.     if hi == hi:
  314.         pass
  315.     elif hi == 1:
  316.         pass
  317.     return av[2][0][0] != SUBPATTERN
  318.  
  319.  
  320. def _compile_info(code, pattern, flags):
  321.     (lo, hi) = pattern.getwidth()
  322.     if lo == 0:
  323.         return None
  324.     
  325.     prefix = []
  326.     prefix_skip = 0
  327.     charset = []
  328.     if not (flags & SRE_FLAG_IGNORECASE):
  329.         for op, av in pattern.data:
  330.             if op is LITERAL:
  331.                 if len(prefix) == prefix_skip:
  332.                     prefix_skip = prefix_skip + 1
  333.                 
  334.                 prefix.append(av)
  335.             elif op is SUBPATTERN and len(av[1]) == 1:
  336.                 (op, av) = av[1][0]
  337.                 if op is LITERAL:
  338.                     prefix.append(av)
  339.                 else:
  340.                     break
  341.             else:
  342.                 break
  343.         
  344.         if not prefix and pattern.data:
  345.             (op, av) = pattern.data[0]
  346.             if op is SUBPATTERN and av[1]:
  347.                 (op, av) = av[1][0]
  348.                 if op is LITERAL:
  349.                     charset.append((op, av))
  350.                 elif op is BRANCH:
  351.                     c = []
  352.                     for p in av[1]:
  353.                         if not p:
  354.                             break
  355.                         
  356.                         (op, av) = p[0]
  357.                         if op is LITERAL:
  358.                             c.append((op, av))
  359.                         else:
  360.                             break
  361.                     else:
  362.                         charset = c
  363.                 
  364.             elif op is BRANCH:
  365.                 c = []
  366.                 for p in av[1]:
  367.                     if not p:
  368.                         break
  369.                     
  370.                     (op, av) = p[0]
  371.                     if op is LITERAL:
  372.                         c.append((op, av))
  373.                     else:
  374.                         break
  375.                 else:
  376.                     charset = c
  377.             elif op is IN:
  378.                 charset = av
  379.             
  380.         
  381.     
  382.     emit = code.append
  383.     emit(OPCODES[INFO])
  384.     skip = len(code)
  385.     emit(0)
  386.     mask = 0
  387.     if prefix:
  388.         mask = SRE_INFO_PREFIX
  389.         if prefix_skip == prefix_skip:
  390.             pass
  391.         elif prefix_skip == len(pattern.data):
  392.             mask = mask + SRE_INFO_LITERAL
  393.         
  394.     elif charset:
  395.         mask = mask + SRE_INFO_CHARSET
  396.     
  397.     emit(mask)
  398.     if lo < MAXCODE:
  399.         emit(lo)
  400.     else:
  401.         emit(MAXCODE)
  402.         prefix = prefix[:MAXCODE]
  403.     if hi < MAXCODE:
  404.         emit(hi)
  405.     else:
  406.         emit(0)
  407.     if prefix:
  408.         emit(len(prefix))
  409.         emit(prefix_skip)
  410.         code.extend(prefix)
  411.         table = [
  412.             -1] + [
  413.             0] * len(prefix)
  414.         for i in range(len(prefix)):
  415.             table[i + 1] = table[i] + 1
  416.             while table[i + 1] > 0 and prefix[i] != prefix[table[i + 1] - 1]:
  417.                 table[i + 1] = table[table[i + 1] - 1] + 1
  418.         
  419.         code.extend(table[1:])
  420.     elif charset:
  421.         _compile_charset(charset, 0, code)
  422.     
  423.     code[skip] = len(code) - skip
  424.  
  425. STRING_TYPES = [
  426.     type('')]
  427.  
  428. try:
  429.     STRING_TYPES.append(type(unicode('')))
  430. except NameError:
  431.     pass
  432.  
  433.  
  434. def _code(p, flags):
  435.     flags = p.pattern.flags | flags
  436.     code = []
  437.     _compile_info(code, p, flags)
  438.     _compile(code, p.data, flags)
  439.     code.append(OPCODES[SUCCESS])
  440.     return code
  441.  
  442.  
  443. def compile(p, flags = 0):
  444.     if type(p) in STRING_TYPES:
  445.         import sre_parse
  446.         pattern = p
  447.         p = sre_parse.parse(p, flags)
  448.     else:
  449.         pattern = None
  450.     code = _code(p, flags)
  451.     groupindex = p.pattern.groupdict
  452.     indexgroup = [
  453.         None] * p.pattern.groups
  454.     for k, i in groupindex.items():
  455.         indexgroup[i] = k
  456.     
  457.     return _sre.compile(pattern, flags, code, p.pattern.groups - 1, groupindex, indexgroup)
  458.  
  459.